home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / pvm34b3.zip / pvm34b3 / pvm3 / console / job.c < prev    next >
C/C++ Source or Header  |  1997-07-22  |  9KB  |  411 lines
  1.  
  2. static char rcsid[] =
  3.     "$Id: job.c,v 1.6 1997/07/09 13:21:07 pvmsrc Exp $";
  4.  
  5. /*
  6.  *         PVM version 3.4:  Parallel Virtual Machine System
  7.  *               University of Tennessee, Knoxville TN.
  8.  *           Oak Ridge National Laboratory, Oak Ridge TN.
  9.  *                   Emory University, Atlanta GA.
  10.  *      Authors:  J. J. Dongarra, G. E. Fagg, M. Fischer
  11.  *          G. A. Geist, J. A. Kohl, R. J. Manchek, P. Mucci,
  12.  *         P. M. Papadopoulos, S. L. Scott, and V. S. Sunderam
  13.  *                   (C) 1997 All Rights Reserved
  14.  *
  15.  *                              NOTICE
  16.  *
  17.  * Permission to use, copy, modify, and distribute this software and
  18.  * its documentation for any purpose and without fee is hereby granted
  19.  * provided that the above copyright notice appear in all copies and
  20.  * that both the copyright notice and this permission notice appear in
  21.  * supporting documentation.
  22.  *
  23.  * Neither the Institutions (Emory University, Oak Ridge National
  24.  * Laboratory, and University of Tennessee) nor the Authors make any
  25.  * representations about the suitability of this software for any
  26.  * purpose.  This software is provided ``as is'' without express or
  27.  * implied warranty.
  28.  *
  29.  * PVM version 3 was funded in part by the U.S. Department of Energy,
  30.  * the National Science Foundation and the State of Tennessee.
  31.  */
  32.  
  33. /*
  34.  *    job.c
  35.  *
  36.  *    Job descriptor / output gathering code.
  37.  *
  38. $Log: job.c,v $
  39.  * Revision 1.6  1997/07/09  13:21:07  pvmsrc
  40.  * Fixed Author Header.
  41.  *
  42.  * Revision 1.5  1997/05/13  14:37:41  pvmsrc
  43.  * Changed header file $includes:
  44.  *     - ../src/listmac.h -> listmac.h
  45.  *     - ../src/bfunc.h -> bfunc.h
  46.  *     - use -I$(PVMDIR)/src in Makefile.aimk instead.
  47.  *
  48.  * Revision 1.4  1997/05/01  15:41:17  pvmsrc
  49.  * SGI Compiler Warning Cleanup.
  50.  *
  51.  * Revision 1.3  1997/01/28  19:13:19  pvmsrc
  52.  * New Copyright Notice & Authors.
  53.  *
  54.  * Revision 1.2  1996/10/24  23:04:30  pvmsrc
  55.  * Updated for new tracing facility:
  56.  *     - removed old checktrace() stuff...
  57.  *
  58.  * Revision 1.1  1996/09/23  20:25:38  pvmsrc
  59.  * Initial revision
  60.  *
  61.  * Revision 1.2  1994/06/03  20:01:52  manchek
  62.  * version 3.3.0
  63.  *
  64.  * Revision 1.1  1993/08/30  23:30:32  manchek
  65.  * Initial revision
  66.  *
  67.  */
  68.  
  69.  
  70. #include <stdio.h>
  71. #ifdef    SYSVSTR
  72. #include <string.h>
  73. #define    CINDEX(s,c)    strchr(s,c)
  74. #else
  75. #include <strings.h>
  76. #define    CINDEX(s,c)    index(s,c)
  77. #endif
  78. #include <pvm3.h>
  79. #include <pvmtev.h>
  80. #include "myalloc.h"
  81. #include "job.h"
  82. #include "listmac.h"
  83. #include "bfunc.h"
  84.  
  85. extern char *pvm_errlist[];
  86. extern int pvm_nerr;
  87.  
  88. extern int mytid;                        /* from cons.c */
  89.  
  90. struct job *joblist = 0;
  91. int nextjob = 4;
  92.  
  93.  
  94. struct job *
  95. job_new(jid)
  96.     int jid;
  97. {
  98.     struct job *jp = joblist->j_link;
  99.     struct job *jp2;
  100.     struct obuf *op;
  101.  
  102.     while (jp != joblist && jp->j_jid < jid)
  103.         jp = jp->j_link;
  104.     if (jp->j_jid != jid) {
  105.         jp2 = TALLOC(1, struct job, "job");
  106.         BZERO((char*)jp2, sizeof(struct job));
  107.         jp2->j_jid = jid;
  108.         op = TALLOC(1, struct obuf, "obuf");
  109.         BZERO((char*)op, sizeof(struct obuf));
  110.         op->o_link = op->o_rlink = op;
  111.         jp2->j_obufs = op;
  112.         LISTPUTBEFORE(jp, jp2, j_link, j_rlink);
  113.         jp = jp2;
  114.     }
  115.     return jp;
  116. }
  117.  
  118.  
  119. job_init()
  120. {
  121.     if (!joblist) {
  122.         joblist = TALLOC(1, struct job, "job");
  123.         BZERO((char*)joblist, sizeof(struct job));
  124.         joblist->j_link = joblist->j_rlink = joblist;
  125.     }
  126.     return 0;
  127. }
  128.  
  129.  
  130. struct job *
  131. job_find(jid)
  132.     int jid;
  133. {
  134.     struct job *jp = joblist->j_link;
  135.  
  136.     while (jp != joblist && jp->j_jid < jid)
  137.         jp = jp->j_link;
  138.     if (jp->j_jid == jid)
  139.         return jp;
  140.     return (struct job*)0;
  141. }
  142.  
  143.  
  144. job_free(jp)
  145.     struct job *jp;
  146. {
  147.     LISTDELETE(jp, j_link, j_rlink);
  148.     if (jp->j_obufs)
  149.         MY_FREE(jp->j_obufs);
  150.     if (jp->j_ff)
  151.         (void)fclose(jp->j_ff);
  152.     MY_FREE(jp);
  153.     return 0;
  154. }
  155.  
  156.  
  157. struct obuf *
  158. obuf_find(jp, tid)
  159.     struct job *jp;
  160.     int tid;
  161. {
  162.     struct obuf *op = jp->j_obufs->o_link;
  163.  
  164.     while (op != jp->j_obufs && op->o_tid < tid)
  165.         op = op->o_link;
  166.     if (op->o_tid == tid)
  167.         return op;
  168.     return (struct obuf*)0;
  169. }
  170.  
  171.  
  172. struct obuf *
  173. obuf_new(jp, tid)
  174.     struct job *jp;
  175.     int tid;
  176. {
  177.     struct obuf *op = jp->j_obufs->o_link;
  178.     struct obuf *op2;
  179.  
  180.     while (op != jp->j_obufs && op->o_tid < tid)
  181.         op = op->o_link;
  182.     if (op->o_tid != tid) {
  183.         op2 = TALLOC(1, struct obuf, "obuf");
  184.         BZERO((char*)op2, sizeof(struct obuf));
  185.         op2->o_tid = tid;
  186.         LISTPUTBEFORE(op, op2, o_link, o_rlink);
  187.         op = op2;
  188.     }
  189.     return op;
  190. }
  191.  
  192.  
  193. obuf_free(jp, op)
  194.     struct job *jp;
  195.     struct obuf *op;
  196. {
  197.     LISTDELETE(op, o_link, o_rlink);
  198.     if (op->o_buf)
  199.         MY_FREE(op->o_buf);
  200.     MY_FREE(op);
  201.     if (jp->j_obufs->o_link == jp->j_obufs) {
  202.         printf("[%d] finished\n", jp->j_jid);
  203.         job_free(jp);
  204.     }
  205.     return 0;
  206. }
  207.  
  208.  
  209. obuf_dump(jp)
  210.     struct job *jp;
  211. {
  212.     struct obuf *op;
  213.  
  214.     for (op = jp->j_obufs->o_link; op != jp->j_obufs; op = op->o_link) {
  215.         printf("obuf_dump() t%x\n", op->o_tid);
  216.     }
  217.     return 0;
  218. }
  219.  
  220.  
  221. checkoutput(jp, cc, len, cod, src)
  222.     struct job *jp;
  223.     int cc;                    /* message mid */
  224.     int len;
  225.     int cod;
  226.     int src;
  227. {
  228.     int tid;                    /* task */
  229.     int n;                        /* length or event code */
  230.     char *p;
  231.     int ptid;
  232.     struct obuf *op;
  233.  
  234.     pvm_upkint(&tid, 1, 1);
  235.     pvm_upkint(&n, 1, 1);
  236.  
  237.     if (n > 0) {
  238.         if (!(op = obuf_find(jp, tid))) {
  239.             printf("Bogus message, job %d has no task t%x\n",
  240.                     jp->j_jid, tid);
  241.             goto hork;
  242.         }
  243.         if (n + op->o_len >= op->o_maxl) {
  244.             op->o_maxl = op->o_len + n + 1;
  245. /*
  246.             printf("REALLOC t%x buf to %d\n", tid, op->o_maxl);
  247. */
  248.             if (op->o_buf)
  249.                 op->o_buf = TREALLOC(op->o_buf, op->o_maxl, char);
  250.             else
  251.                 op->o_buf = TALLOC(op->o_maxl, char, "");
  252.         }
  253.         pvm_upkbyte(op->o_buf + op->o_len, n, 1);
  254.         op->o_buf[op->o_len + n] = 0;
  255. /*
  256.         printf("UNPACK t%x {%s}\n", tid, op->o_buf + op->o_len);
  257. */
  258.         p = op->o_buf + op->o_len;
  259.         op->o_len += n;
  260.         while (p = CINDEX(p, '\n')) {
  261.             *p++ = 0;
  262.             fprintf((jp->j_ff ? jp->j_ff : stdout),
  263.                     "[%d:t%x] %s\n", jp->j_jid, tid, op->o_buf);
  264.             op->o_len -= p - op->o_buf;
  265.             BCOPY(p, op->o_buf, op->o_len);
  266.             p = op->o_buf;
  267.         }
  268.  
  269.     } else {
  270.         switch (n) {
  271.  
  272.         case 0:
  273.             if (!(op = obuf_find(jp, tid))) {
  274.                 printf("Bogus message, job %d has no task t%x\n",
  275.                         jp->j_jid, tid);
  276.                 goto hork;
  277.             }
  278.             if (op->o_len > 0) {
  279.                 fprintf((jp->j_ff ? jp->j_ff : stdout),
  280.                         "[%d:t%x] %s\n", jp->j_jid, tid, op->o_buf);
  281.                 op->o_len = 0;
  282.             }
  283.             op->o_flag |= GOTEOF;
  284.             if (op->o_flag == (GOTSPAWN|GOTEOF)) {
  285.                 fprintf((jp->j_ff ? jp->j_ff : stdout),
  286.                         "[%d:t%x] EOF\n", jp->j_jid, tid);
  287.                 obuf_free(jp, op);
  288.             }
  289.             break;
  290.  
  291.         case -1:
  292.             if (!(op = obuf_find(jp, tid)))
  293.                 op = obuf_new(jp, tid);
  294. /*
  295.             pvm_upkint(&ptid, 1, 1);
  296. */
  297.             op->o_flag |= GOTSPAWN;
  298.             if (op->o_flag == (GOTSPAWN|GOTEOF)) {
  299.                 fprintf((jp->j_ff ? jp->j_ff : stdout),
  300.                         "[%d:t%x] EOF\n", jp->j_jid, tid);
  301.                 obuf_free(jp, op);
  302.             }
  303.  
  304.             break;
  305.  
  306.         case -2:
  307.             if (!(op = obuf_find(jp, tid)))
  308.                 op = obuf_new(jp, tid);
  309. /*
  310.             pvm_upkint(&ptid, 1, 1);
  311. */
  312.             break;
  313.  
  314.         default:
  315.             printf("Bogus message from job %d task t%x\n",
  316.                 jp->j_jid, tid);
  317.             break;
  318.         }
  319.     }
  320.  
  321. hork:
  322.     pvm_freebuf(cc);
  323.     return 0;
  324. }
  325.  
  326.  
  327. checktrace(jp, cc, len, cod, src)
  328.     struct job *jp;
  329.     int cc;                    /* message mid */
  330.     int len;
  331.     int cod;
  332.     int src;
  333. {
  334.     int tid;                    /* task */
  335.     int kind;                    /* length or event code */
  336.     int sec, usec;
  337.     char *p;
  338.     int ptid;
  339.     struct obuf *op;
  340.  
  341.     pvm_upkint(&sec, 1, 1);
  342.     pvm_upkint(&usec, 1, 1);
  343.     pvm_upkint(&tid, 1, 1);
  344.     pvm_upkint(&kind, 1, 1);
  345.  
  346.     if (kind >= 0 && kind <= TEV_MAX) {
  347.  
  348.         if (!(op = obuf_find(jp, tid)))
  349.             op = obuf_new(jp, tid);
  350.  
  351.         op->o_flag |= GOTSPAWN;
  352.  
  353.         if (!(op = obuf_find(jp, tid))) {
  354.             printf("Bogus message, job %d has no task t%x\n",
  355.                     jp->j_jid, tid);
  356.             goto hork;
  357.         }
  358.  
  359.         fprintf((jp->j_ff ? jp->j_ff : stdout), "[T%d:t%x] %d.%06d ",
  360.                 jp->j_jid, tid, sec, usec);
  361.  
  362.         fprintf((jp->j_ff ? jp->j_ff : stdout), "\n");
  363.  
  364.         switch (kind) {
  365.  
  366.         case TEV_ENDTASK:    /* EOF */
  367.             if (!(op = obuf_find(jp, tid))) {
  368.                 printf("Bogus message, job %d has no task t%x\n",
  369.                         jp->j_jid, tid);
  370.                 goto hork;
  371.             }
  372.             op->o_flag |= GOTEOF;
  373.             if (op->o_flag == (GOTSPAWN|GOTEOF)) {
  374.                 fprintf((jp->j_ff ? jp->j_ff : stdout),
  375.                         "[T%d:t%x] END\n", jp->j_jid, tid);
  376.                 obuf_free(jp, op);
  377.             }
  378.             break;
  379.  
  380.         case TEV_SPNTASK:    /* tm_spawn */
  381.             if (!(op = obuf_find(jp, tid)))
  382.                 op = obuf_new(jp, tid);
  383.             op->o_flag |= GOTSPAWN;
  384.             if (op->o_flag == (GOTSPAWN|GOTEOF)) {
  385.                 fprintf((jp->j_ff ? jp->j_ff : stdout),
  386.                         "[T%d:t%x] END\n", jp->j_jid, tid);
  387.                 obuf_free(jp, op);
  388.             }
  389.  
  390.             break;
  391.  
  392.         case TEV_NEWTASK:    /* dm_exec */
  393.             if (!(op = obuf_find(jp, tid)))
  394.                 op = obuf_new(jp, tid);
  395.             break;
  396.  
  397.         default:
  398.             break;
  399.         }
  400.  
  401.     } else {
  402.         printf("Bogus message from job %d task t%x\n", jp->j_jid, tid);
  403.     }
  404.  
  405. hork:
  406.     pvm_freebuf(cc);
  407.     return 0;
  408. }
  409.  
  410.  
  411.